1 /**
2   hdf5.wrap
3 
4   D Language wrappers for the HDF5 Library.  (Paired with a set of lower-level bindings)
5   https://github.com/Laeeth/d_hdf5
6 
7   No restriction on use beyond those applying from HDF5 and the original C API by Stefan Frijters
8   However, if you use them, I would not mind knowing your application and suggestions for
9   improvement if you feel like sharing.  laeeth@laeeth.com
10 
11    Copyright by The HDF Group.                                               *
12   Copyright by the Board of Trustees of the University of Illinois.         *
13   All rights reserved.                                                      *
14                                                                             *
15   This file is part of HDF5.  The full HDF5 copyright notice, including     *
16   terms governing use, modification, and redistribution, is contained in    *
17   the files COPYING and Copyright.html.  COPYING can be found at the root   *
18   of the source code distribution tree; Copyright.html can be found at the  *
19   root level of an installed copy of the electronic HDF5 document set and   *
20   is linked from the top-level documents page.  It can also be found at     *
21   http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
22   access to either file, you may request a copy from help@hdfgroup.org.     *
23   * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
24   Ported to D by Laeeth Isharc 2014
25   Borrowed heavily in terms of C API declarations from https://github.com/SFrijters/hdf5-d
26   Stefan Frijters bindings for D
27 
28   I do not think these are complete, and I also wanted to begin to work on a higher level D
29   interface.  Initially just using strings instead of chars, for example.  And exceptions
30   instead of checking status code each time.  Later will add a higher level interface similarly
31   to how it is done in h5py.
32 
33   Consider this not even alpha stage.  It probably isn't so far away from being useful though.
34   This is written for Linux and will need modification to work on other platforms.
35 
36 
37   To Do:
38     1. Better exception handling that calls HDF5 to get error and returns appropriate Throwable object
39     2. Unit tests
40     3. Thoughtfulness about using D CFTE/reflection/templating to make it work better - also variants etc
41           should be able to pass the data structure not cast(ubyte*)
42           should automatically use reflection to deal with structs etc
43 */
44 
45 module hdf5.wrap;
46 public import core.stdc.stdint;
47 public import core.sys.posix.sys.types: off_t;
48 public import core.stdc.time;
49 public import core.stdc.stdint;
50 import std.conv;
51 import std..string;
52 import std.array;
53 import std.stdio;
54 import hdf5.bindings.enums;
55 import hdf5.bindings.api;
56 import hdf5.wrap;
57 
58 void throwOnError(int status)
59 {
60 	if (status>=0)
61 		return;
62 	else
63 		throw new Exception("HDF5 error - check message");
64 }
65 
66 string ZtoString(const char[] c)
67 {
68     return to!string(fromStringz(cast(char*)c));
69 }
70 
71 string ZtoString(const char* c)
72 {
73     return to!string(fromStringz(c));
74 }
75 
76 struct H5A
77 {
78   static {
79   hid_t create2(hid_t loc_id, string attr_name, hid_t type_id, hid_t space_id, hid_t acpl_id, hid_t aapl_id)
80   {
81     return H5Acreate2(loc_id,toStringz(attr_name),type_id,space_id,acpl_id,aapl_id);
82   }
83  
84  
85   hid_t create_by_name(hid_t loc_id, string obj_name, string attr_name,hid_t type_id, hid_t space_id, hid_t acpl_id, hid_t aapl_id, hid_t lapl_id)
86 
87   {
88     return H5Acreate_by_name(loc_id,toStringz(obj_name),toStringz(attr_name),type_id,space_id,acpl_id,aapl_id,lapl_id);
89   }
90  
91   hid_t open(hid_t obj_id, string attr_name, hid_t aapl_id)
92   {
93     return H5Aopen(obj_id,toStringz(attr_name),aapl_id);
94   }
95  
96  
97   hid_t open_by_name(hid_t loc_id, string obj_name, string attr_name, hid_t aapl_id, hid_t lapl_id)
98   {
99     return H5Aopen_by_name(loc_id,toStringz(obj_name), toStringz(attr_name),aapl_id,lapl_id);
100   }
101  
102  
103   hid_t open_by_idx(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t aapl_id, hid_t lapl_id)
104   {
105     return H5Aopen_by_idx(loc_id,toStringz(obj_name),idx_type,order,n,aapl_id,lapl_id);
106   }
107  
108  
109   void write(hid_t attr_id, hid_t type_id, const (ubyte*) buf)
110   {
111     throwOnError(H5Awrite(attr_id,type_id,buf));
112   }
113  
114  
115   void read(hid_t attr_id, hid_t type_id, ubyte* buf)
116   {
117     throwOnError(H5Aread(attr_id,type_id,buf));
118   }
119  
120  
121   void close(hid_t attr_id)
122   {
123     throwOnError( H5Aclose(attr_id));
124   }
125  
126  
127   hid_t get_space(hid_t attr_id)
128   {
129     return H5Aget_space(attr_id);
130   }
131  
132  
133   hid_t get_type(hid_t attr_id)
134   {
135     return H5Aget_type(attr_id);
136   }
137  
138  
139   hid_t get_create_plist(hid_t attr_id)
140   {
141     return   H5Aget_create_plist(attr_id);
142   }
143  
144  
145   string get_name(hid_t attr_id)
146   {
147     char[2048] buf;
148     if (H5Aget_name(attr_id,buf.length,cast(char*)buf)<=0)
149       return "";
150     else
151       return ZtoString(buf[]);
152   }
153  
154  
155   string get_name_by_idx(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t lapl_id)
156   {
157     char[2048] buf;
158     if (H5Aget_name_by_idx(loc_id,toStringz(obj_name),idx_type,order,n,cast(char*)buf,buf.length,lapl_id)<=0)
159       return "";
160     else
161       return ZtoString(buf[]);
162   }
163  
164  
165   hsize_t get_storage_size(hid_t attr_id)
166   {
167     return H5Aget_storage_size(attr_id);
168   }
169  
170  
171   void get_info(hid_t attr_id, H5A_info_t *ainfo /*out*/)
172   {
173     throwOnError( H5Aget_info(attr_id,ainfo));
174   }
175  
176  
177   void get_info_by_name(hid_t loc_id, string obj_name, string attr_name, H5A_info_t *ainfo /*out*/, hid_t lapl_id)
178   {
179     throwOnError( H5Aget_info_by_name(loc_id,toStringz(obj_name),toStringz(attr_name),ainfo,lapl_id));
180   }
181  
182  
183   void get_info_by_idx(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, hsize_t n, H5A_info_t *ainfo /*out*/, hid_t lapl_id)
184   {
185     throwOnError( H5Aget_info_by_idx(loc_id,toStringz(obj_name),idx_type,order,n,ainfo,lapl_id));
186   }
187  
188  
189   void rename(hid_t loc_id, string old_name, string new_name)
190   {
191     throwOnError( H5Arename(loc_id,toStringz(old_name),toStringz(new_name)));
192   }
193  
194  
195   void rename_by_name(hid_t loc_id, string obj_name, string old_attr_name, string new_attr_name, hid_t lapl_id)
196   {
197     throwOnError( H5Arename_by_name(loc_id,toStringz(obj_name),toStringz(old_attr_name),toStringz(new_attr_name),lapl_id));
198   }
199  
200  
201   void iterate2(hid_t loc_id, H5Index idx_type, H5IterOrder order, hsize_t *idx, H5A_operator2_t op, void *op_data)
202   {
203     throwOnError(H5Aiterate2(loc_id,idx_type,order,idx,op,op_data));
204   }
205  
206   void iterate_by_name(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, hsize_t *idx, H5A_operator2_t op, void *op_data, hid_t lapd_id)
207   {
208     throwOnError(H5Aiterate_by_name(loc_id, toStringz(obj_name),idx_type,order,idx, op,op_data,lapd_id));
209   }
210  
211   void h5delete(hid_t loc_id, string name)
212   {
213     throwOnError( H5Adelete(loc_id,toStringz(name)));
214   }
215  
216  
217   void delete_by_name(hid_t loc_id, string obj_name, string attr_name, hid_t lapl_id)
218   {
219     throwOnError( H5Adelete_by_name(loc_id,toStringz(obj_name),toStringz(attr_name),lapl_id));
220   }
221  
222  
223   void delete_by_idx(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t lapl_id)
224   {
225     throwOnError( H5Adelete_by_idx(loc_id,toStringz(obj_name),idx_type,order,n,lapl_id));
226   }
227  
228  
229   htri_t exists(hid_t obj_id, string attr_name)
230   {
231     return H5Aexists(obj_id,toStringz(attr_name));
232   }
233  
234  
235   htri_t exists_by_name(hid_t obj_id, string obj_name, string attr_name, hid_t lapl_id)
236   {
237     return H5Aexists_by_name(obj_id,toStringz(obj_name),toStringz(attr_name),lapl_id);
238   }
239   } // static
240 }
241 
242 
243 struct H5D
244 {
245   static
246   {
247 // alias - hope it is correct!
248   hid_t create2(hid_t loc_id, string name, hid_t type_id, hid_t space_id, hid_t lcpl_id, hid_t dcpl_id, hid_t dapl_id)
249   {
250     return H5Dcreate2(loc_id, toStringz(name), type_id,  space_id,  lcpl_id,  dcpl_id, dapl_id);
251   }
252 
253   hid_t create_anon(hid_t file_id, hid_t type_id, hid_t space_id, hid_t plist_id, hid_t dapl_id)
254   {
255     return H5Dcreate_anon( file_id,  type_id,  space_id,  plist_id,  dapl_id);
256   }
257   hid_t open2(hid_t file_id, string name, hid_t dapl_id)
258   {
259     return H5Dopen2( file_id, toStringz(name), dapl_id);
260   }
261   void close(hid_t dset_id)
262   {
263     throwOnError(H5Dclose(dset_id));    
264   }
265   hid_t get_space(hid_t dset_id)
266   {
267       return H5Dget_space(dset_id);
268   }
269   H5DSpaceStatus get_space_status(hid_t dset_id)
270   {
271     H5DSpaceStatus allocation;
272     throwOnError(H5Dget_space_status(dset_id, &allocation));
273     return allocation;
274   }
275   hid_t get_type(hid_t dset_id)
276   {
277     return H5Dget_type(dset_id);
278   }
279   
280   hid_t get_create_plist(hid_t dset_id)
281   {
282       return H5Dget_create_plist(dset_id);
283   }
284   hid_t get_access_plist(hid_t dset_id)
285   {
286       return H5Dget_access_plist(dset_id);
287   }
288   hsize_t get_storage_size(hid_t dset_id)
289   {
290     return H5Dget_storage_size(dset_id);
291   }
292   haddr_t get_offset(hid_t dset_id)
293   {
294       return H5Dget_offset(dset_id);
295   }
296   void read(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t plist_id, ubyte* buf/*out*/)
297   {
298       throwOnError(H5Dread(dset_id, mem_type_id, mem_space_id, file_space_id, plist_id,cast(void*)buf/*out*/));
299   }
300   void write(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t plist_id, ubyte* buf)
301   {
302     throwOnError(H5Dwrite(dset_id, mem_type_id, mem_space_id, file_space_id, plist_id,cast(void*)buf));
303   }
304 
305   void iterate(void *buf, hid_t type_id, hid_t space_id, H5D_operator_t op, void *operator_data)
306   {
307     throwOnError(H5Diterate(buf,type_id,  space_id, op,operator_data));
308   }
309   void vlen_reclaim(hid_t type_id, hid_t space_id, hid_t plist_id, void *buf)
310   {
311       throwOnError(H5Dvlen_reclaim(type_id,  space_id, plist_id, buf));
312   }
313   void vlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_id, hsize_t *size)
314   {
315       throwOnError(H5Dvlen_get_buf_size( dataset_id, type_id, space_id,size));
316   }      
317   void fill(const void *fill, hid_t fill_type, void *buf, hid_t buf_type, hid_t space)
318   {
319     throwOnError(H5Dfill(fill, fill_type, buf, buf_type, space));
320   }
321   void set_extent(hid_t dset_id, const hsize_t[] size)
322   {
323       throwOnError(H5Dset_extent(dset_id, size.ptr));
324   }
325   void scatter(H5D_scatter_func_t op, void *op_data, hid_t type_id, hid_t dst_space_id, void *dst_buf)
326   {
327     throwOnError(H5Dscatter(op, op_data, type_id,  dst_space_id, dst_buf));
328   }
329   void gather(hid_t src_space_id, const void *src_buf, hid_t type_id, size_t dst_buf_size, void *dst_buf, H5D_gather_func_t op, void *op_data)
330   {
331        throwOnError(H5Dgather(src_space_id, src_buf, type_id, dst_buf_size,dst_buf, op, op_data));
332   }
333   void h5debug(hid_t dset_id)
334   {
335     throwOnError(H5Ddebug(dset_id));
336   }
337   }// static
338 }
339 
340 struct H5F
341 {
342   static
343   {
344   htri_t is_hdf5(string filename)
345   {
346     return H5Fis_hdf5(toStringz(filename));
347   }
348 
349   hid_t create(string filename, uint flags, hid_t create_plist, hid_t access_plist)
350   {
351     return H5Fcreate(toStringz(filename),flags,create_plist,access_plist);
352   }
353 
354   hid_t open(string filename, uint flags, hid_t access_plist)
355   {
356     return H5Fopen(toStringz(filename),flags,access_plist);
357   }
358 
359 
360   hid_t reopen(hid_t file_id)
361   {
362     return H5Freopen(file_id);
363   }
364 
365 
366   void flush(hid_t object_id, H5F_scope_t _scope)
367   {
368     throwOnError(H5Fflush(object_id,_scope));
369   }
370 
371 
372   void close(hid_t file_id)
373   {
374     throwOnError(H5Fclose(file_id));
375   }
376 
377 
378   hid_t get_create_plist(hid_t file_id)
379   {
380     return H5Fget_create_plist(file_id);
381   }
382 
383 
384   hid_t get_access_plist(hid_t file_id)
385   {
386     return H5Fget_access_plist(file_id);
387   }
388 
389 
390   void get_intent(hid_t file_id, uint * intent)
391   {
392     throwOnError(H5Fget_intent(file_id,intent));
393   }
394 
395 
396   ssize_t get_obj_count(hid_t file_id, uint types)
397   {
398     return H5Fget_obj_count(file_id,types);
399   }
400 
401 
402   ssize_t get_obj_ids(hid_t file_id, uint types, size_t max_objs, hid_t *obj_id_list)
403   {
404     return H5Fget_obj_ids(file_id,types,max_objs,obj_id_list);
405   }
406 
407 
408   void get_vfd_handle(hid_t file_id, hid_t fapl, void **file_handle)
409   {
410     throwOnError(H5Fget_vfd_handle(file_id,fapl,file_handle));
411   }
412 
413 
414   void mount(hid_t loc, string name, hid_t child, hid_t plist)
415   {
416     throwOnError(H5Fmount(loc,toStringz(name),child,plist));
417   }
418 
419 
420   void unmount(hid_t loc, string name)
421   {
422     throwOnError(H5Funmount(loc,toStringz(name)));
423   }
424 
425 
426   hssize_t get_freespace(hid_t file_id)
427   {
428     return H5Fget_freespace(file_id);
429   }
430 
431 
432   void get_filesize(hid_t file_id, hsize_t *size)
433   {
434     throwOnError(H5Fget_filesize(file_id,size));
435   }
436 
437 
438   ssize_t get_file_image(hid_t file_id, void * buf_ptr, size_t buf_len)
439   {
440     return H5Fget_file_image(file_id,buf_ptr,buf_len);
441   }
442 
443 
444   void get_mdc_hit_rate(hid_t file_id, double * hit_rate_ptr)
445   {
446     throwOnError(H5Fget_mdc_hit_rate(file_id,hit_rate_ptr));
447   }
448 
449 
450   void get_mdc_size(hid_t file_id, size_t * max_size_ptr, size_t * min_clean_size_ptr, size_t * cur_size_ptr, int * cur_num_entries_ptr)
451   {
452     throwOnError(H5Fget_mdc_size(file_id,max_size_ptr,min_clean_size_ptr,cur_size_ptr,cur_num_entries_ptr));
453   }
454 
455 
456   void reset_mdc_hit_rate_stats(hid_t file_id)
457   {
458     throwOnError(H5Freset_mdc_hit_rate_stats(file_id));
459   }
460 
461 
462   ssize_t get_name(hid_t obj_id, char *name, size_t size)
463   {
464     return H5Fget_name(obj_id,name,size);
465   }
466 
467 
468   void get_info(hid_t obj_id, H5F_info_t *bh_info)
469   {
470     throwOnError(H5Fget_info(obj_id,bh_info));
471   }
472 
473 
474   void clear_elink_file_cache(hid_t file_id)
475   {
476     throwOnError(H5Fclear_elink_file_cache(file_id));
477   }
478 
479 
480   version(h5parallel)
481   {
482     void set_mpi_atomicity(hid_t file_id, hbool_t flag)
483     {
484       throwOnError(H5Fset_mpi_atomicity(file_id,flag));
485     }
486 
487 
488     void get_mpi_atomicity(hid_t file_id, hbool_t *flag)
489     {
490       throwOnError(H5Fget_mpi_atomicity(file_id,flag));
491     }
492   }
493   }// static
494 }
495 
496 struct H5G
497 {
498   static
499   {
500   hid_t create2(hid_t loc_id, string name, hid_t lcpl_id, hid_t gcpl_id, hid_t gapl_id)
501   {
502     return H5Gcreate2(loc_id,toStringz(name),lcpl_id,gcpl_id,gapl_id);
503   }
504  
505   hid_t create_anon(hid_t loc_id, hid_t gcpl_id, hid_t gapl_id)
506   {
507     return H5Gcreate_anon(loc_id,gcpl_id,gapl_id);
508   }
509  
510  
511   hid_t open2(hid_t loc_id, string name, hid_t gapl_id)
512   {
513     return H5Gopen2(loc_id,toStringz(name),gapl_id);
514   }
515  
516  
517   hid_t get_create_plist(hid_t group_id)
518   {
519     return H5Gget_create_plist(group_id);
520   }
521  
522  
523   void get_info(hid_t loc_id, H5GInfo *ginfo)
524   {
525     throwOnError(H5Gget_info(loc_id,ginfo));
526   }
527  
528  
529   void get_info_by_name(hid_t loc_id, string name, H5GInfo *ginfo, hid_t lapl_id)
530   {
531     throwOnError(H5Gget_info_by_name(loc_id,toStringz(name),ginfo,lapl_id));
532   }
533  
534  
535   void get_info_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, H5GInfo *ginfo, hid_t lapl_id)
536   {
537     throwOnError(H5Gget_info_by_idx(loc_id,toStringz(group_name),idx_type,order,n,ginfo,lapl_id));
538   }
539  
540  
541   void close(hid_t group_id)
542   {
543     throwOnError(H5Gclose(group_id));
544   }
545   }//static
546 }
547  
548 struct H5I
549 {
550   static
551   {
552   hid_t register(H5IType type, const void *object)
553   {
554     return H5Iregister(type,object);
555   }
556  
557  
558   void *object_verify(hid_t id, H5IType id_type)
559   {
560     return H5Iobject_verify(id,id_type);
561   }
562  
563  
564   void *remove_verify(hid_t id, H5IType id_type)
565   {
566     return H5Iremove_verify(id,id_type);
567   }
568  
569  
570   H5IType get_type(hid_t id)
571   {
572     return H5Iget_type(id);
573   }
574  
575  
576   hid_t get_file_id(hid_t id)
577   {
578     return H5Iget_file_id(id);
579   }
580  
581  
582   string get_name(hid_t id)
583   {
584     char[2048] buf;
585     if(H5Iget_name(id,buf.ptr,buf.length)<=0)
586       return "";
587     else
588       return ZtoString(buf[]);
589   }
590  
591  
592   int inc_ref(hid_t id)
593   {
594     return H5Iinc_ref(id);
595   }
596  
597  
598   int dec_ref(hid_t id)
599   {
600     return H5Idec_ref(id);
601   }
602  
603  
604   int get_ref(hid_t id)
605   {
606     return H5Iget_ref(id);
607   }
608  
609  
610   H5IType register_type(size_t hash_size, uint reserved, H5I_free_t free_func)
611   {
612     return H5Iregister_type(hash_size,reserved,free_func);
613   }
614  
615  
616   void clear_type(H5IType type, hbool_t force)
617   {
618     throwOnError(H5Iclear_type(type,force));
619   }
620  
621  
622   void destroy_type(H5IType type)
623   {
624     throwOnError(H5Idestroy_type(type));
625   }
626  
627  
628   int inc_type_ref(H5IType type)
629   {
630     return H5Iinc_type_ref(type);
631   }
632  
633  
634   int dec_type_ref(H5IType type)
635   {
636     return H5Idec_type_ref(type);
637   }
638  
639  
640   int get_type_ref(H5IType type)
641   {
642     return H5Iget_type_ref(type);
643   }
644  
645  
646   void *H5Isearch(H5IType type, H5I_search_func_t func, void *key)
647   {
648     return H5Isearch(type,func,key);
649   }
650  
651  
652   void nmembers(H5IType type, hsize_t *num_members)
653   {
654     throwOnError(H5Inmembers(type,num_members));
655   }
656  
657  
658   htri_t type_exists(H5IType type)
659   {
660     return H5Itype_exists(type);
661   }
662  
663  
664   htri_t is_valid(hid_t id)
665   {
666     return H5Iis_valid(id);
667   }
668   }//static
669 }
670 struct H5L
671 {
672   static {
673   void move(hid_t src_loc, string src_name, hid_t dst_loc, string dst_name, hid_t lcpl_id, hid_t lapl_id)
674   {
675     throwOnError(H5Lmove(src_loc,toStringz(src_name),dst_loc,toStringz(dst_name),lcpl_id,lapl_id));
676   }
677  
678  
679   void copy(hid_t src_loc, string src_name, hid_t dst_loc, string dst_name, hid_t lcpl_id, hid_t lapl_id)
680   {
681     throwOnError(H5Lcopy(src_loc,toStringz(src_name),dst_loc,toStringz(dst_name),lcpl_id,lapl_id));
682   }
683  
684  
685   void create_hard(hid_t cur_loc, string cur_name, hid_t dst_loc, string dst_name, hid_t lcpl_id, hid_t lapl_id)
686   {
687     throwOnError(H5Lcreate_hard(cur_loc,toStringz(cur_name),dst_loc,toStringz(dst_name),lcpl_id,lapl_id));
688   }
689  
690  
691   void create_soft(string link_target, hid_t link_loc_id, string link_name, hid_t lcpl_id, hid_t lapl_id)
692   {
693     throwOnError(H5Lcreate_soft(toStringz(link_target),link_loc_id,toStringz(link_name),lcpl_id,lapl_id));
694   }
695  
696  
697   void h5delete(hid_t loc_id, string name, hid_t lapl_id)
698   {
699     throwOnError(H5Ldelete(loc_id,toStringz(name),lapl_id));
700   }
701  
702  
703   void delete_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t lapl_id)
704   {
705     throwOnError(H5Ldelete_by_idx(loc_id,toStringz(group_name), idx_type,order,n,lapl_id));
706   }
707  
708  
709   void get_val(hid_t loc_id, string name, void *buf/*out*/, size_t size, hid_t lapl_id)
710   {
711     throwOnError(H5Lget_val( loc_id,toStringz(name), buf/*out*/,  size, lapl_id));
712   }
713  
714  
715   void get_val_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, void *buf/*out*/, size_t size, hid_t lapl_id)
716   {
717     throwOnError(H5Lget_val_by_idx(loc_id,toStringz(group_name),idx_type,order,n,buf/*out*/,size,lapl_id));
718   }
719  
720  
721   htri_t exists(hid_t loc_id, string name, hid_t lapl_id)
722   {
723     return H5Lexists(loc_id,toStringz(name),lapl_id);
724   }
725  
726  
727   auto get_info(hid_t loc_id, string name, hid_t lapl_id)
728   {
729     auto info=new H5LInfo;
730     throwOnError(H5Lget_info(loc_id,toStringz(name),info,lapl_id));
731     return *info;
732   }
733      
734   void get_info_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, H5LInfo *linfo /*out*/, hid_t lapl_id)
735   {
736     throwOnError(H5Lget_info_by_idx(loc_id,toStringz(group_name),idx_type,order,n,linfo,lapl_id));
737   }
738  
739  
740   string get_name_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t lapl_id)
741   {
742     char[2048] buf;
743     if (H5Lget_name_by_idx(loc_id,toStringz(group_name),idx_type,order,n,cast(char*)buf,buf.length,lapl_id)<=0)
744       return "";
745     else
746     {
747       return ZtoString(buf[]);
748     }
749   }
750  
751   void iterate(hid_t grp_id, H5Index idx_type, H5IterOrder order,H5L_iterate_t op)
752   {
753     throwOnError(H5Literate(grp_id,idx_type,order,cast(hsize_t*)0,op,cast(void*)0));
754   }
755  
756   void iterate(hid_t grp_id, H5Index idx_type, H5IterOrder order, hsize_t *idx, H5L_iterate_t op, void *op_data)
757   {
758     throwOnError(H5Literate(grp_id,idx_type,order,idx,op,op_data));
759   }
760  
761   void iterate_by_name(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, H5L_iterate_t op, hid_t lapl_id)
762   {
763     throwOnError(H5Literate_by_name(loc_id,toStringz(group_name),idx_type,order,cast(hsize_t*)0,op,cast(void*)0,lapl_id));
764   }
765 
766  
767   void iterate_by_name(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t *idx, H5L_iterate_t op, void *op_data, hid_t lapl_id)
768   {
769     throwOnError(H5Literate_by_name(loc_id,toStringz(group_name),idx_type,order,idx,op,op_data,lapl_id));
770   }
771 
772   void visit(hid_t grp_id, H5Index idx_type, H5IterOrder order, H5L_iterate_t op, void *op_data)
773   {
774     throwOnError(H5Lvisit(grp_id, idx_type, order,op, op_data));
775   }
776   
777   void visit_by_name(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, H5L_iterate_t op, void *op_data, hid_t lapl_id)
778   {
779     throwOnError(H5Lvisit_by_name(loc_id,toStringz(group_name),idx_type,order,op,op_data,lapl_id));
780   }
781  
782   void create_ud(hid_t link_loc_id, string link_name, H5LType link_type, const void *udata, size_t udata_size, hid_t lcpl_id, hid_t lapl_id)
783   {
784     throwOnError(H5Lcreate_ud(link_loc_id,toStringz(link_name),link_type,udata,udata_size,lcpl_id,lapl_id));
785   }
786  
787  
788   void register(const H5L_class_t *cls)
789   {
790     throwOnError(H5Lregister(cls));
791   }
792  
793  
794   void unregister(H5LType id)
795   {
796     throwOnError(H5Lunregister(id));
797   }
798  
799  
800   htri_t is_registered(H5LType id)
801   {
802     return H5Lis_registered(id);
803   }
804  
805  
806   string[2] unpack_elink_val(const void *ext_linkval/*in*/, size_t link_size, uint *flags)
807   {
808     char *filename;
809     char *obj_path;
810     throwOnError(H5Lunpack_elink_val(ext_linkval, link_size,flags,&filename,&obj_path));
811     return [ZtoString(filename),ZtoString(obj_path)];
812   }
813  
814  
815   void create_external(string file_name, string obj_name, hid_t link_loc_id, string link_name, hid_t lcpl_id, hid_t lapl_id)
816   {
817     throwOnError(H5Lcreate_external(toStringz(file_name),toStringz(obj_name),link_loc_id,toStringz(link_name),lcpl_id,lapl_id));
818   }
819   }//static
820 }
821  
822 struct H5O
823 {
824   static
825   {
826   hid_t open(hid_t loc_id, string name, hid_t lapl_id)
827   {
828     return H5Oopen(loc_id,toStringz(name),lapl_id);
829   }
830  
831   hid_t open_by_addr(hid_t loc_id, haddr_t addr)
832   {
833     return H5Oopen_by_addr(loc_id,addr);
834   }
835  
836   hid_t open_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, hid_t lapl_id)
837   {
838     return H5Oopen_by_idx(loc_id,toStringz(group_name),idx_type,order,n,lapl_id);
839   }
840  
841   htri_t exists_by_name(hid_t loc_id, string name, hid_t lapl_id)
842   {
843     return H5Oexists_by_name(loc_id,toStringz(name),lapl_id);
844   }
845  
846   void get_info(hid_t loc_id, H5OInfo  *oinfo)
847   {
848     throwOnError(H5Oget_info(loc_id,oinfo));
849   }
850  
851   void get_info_by_name(hid_t loc_id, string name, H5OInfo  *oinfo, hid_t lapl_id)
852   {
853     //writefln("getinfobyname: %s",name);
854     throwOnError(H5Oget_info_by_name(loc_id,toStringz(name),oinfo,lapl_id));
855     //writefln("passed throw");
856   }
857  
858  
859   void get_info_by_idx(hid_t loc_id, string group_name, H5Index idx_type, H5IterOrder order, hsize_t n, H5OInfo  *oinfo, hid_t lapl_id)
860   {
861     throwOnError(H5Oget_info_by_idx(loc_id,toStringz(group_name),idx_type,order,n,oinfo,lapl_id));
862   }
863  
864   void link(hid_t obj_id, hid_t new_loc_id, string new_name, hid_t lcpl_id, hid_t lapl_id)
865   {
866     throwOnError(H5Olink(obj_id,new_loc_id,toStringz(new_name),lcpl_id,lapl_id));
867   }
868  
869  
870   void incr_refcount(hid_t object_id)
871   {
872     throwOnError(H5Oincr_refcount(object_id));
873   }
874  
875  
876   void decr_refcount(hid_t object_id)
877   {
878     throwOnError(H5Odecr_refcount(object_id));
879   }
880  
881  
882   void copy(hid_t src_loc_id, string src_name, hid_t dst_loc_id, string dst_name, hid_t ocpypl_id, hid_t lcpl_id)
883   {
884     throwOnError(H5Ocopy(src_loc_id,toStringz(src_name),dst_loc_id,toStringz(dst_name),ocpypl_id,lcpl_id));
885   }
886  
887  
888   void set_comment(hid_t obj_id, string comment)
889   {
890     throwOnError(H5Oset_comment(obj_id,toStringz(comment)));
891   }
892  
893  
894   void set_comment_by_name(hid_t loc_id, string name, string comment, hid_t lapl_id)
895   {
896     throwOnError(H5Oset_comment_by_name(loc_id,toStringz(name),toStringz(comment),lapl_id));
897   }
898  
899  
900   string get_comment(hid_t obj_id)
901   {
902     char[2048] buf;
903     if (H5Oget_comment(obj_id,cast(char*)buf,buf.length)<=0)
904       return "";
905     else
906       return ZtoString(buf[]);
907   }
908  
909  
910   string get_comment_by_name(hid_t loc_id, string name, hid_t lapl_id)
911   {
912     char[2048] buf;
913     if (H5Oget_comment_by_name(loc_id,toStringz(name),cast(char*)buf,buf.length,lapl_id)<=0)
914       return "";
915     else
916       return ZtoString(buf[]);
917   }
918  
919  
920   void visit(hid_t obj_id, H5Index idx_type, H5IterOrder order, H5O_iterate_t op, void *op_data)
921   {
922     throwOnError(H5Ovisit(obj_id,idx_type,order,op,op_data));
923   }
924  
925  
926   void visit_by_name(hid_t loc_id, string obj_name, H5Index idx_type, H5IterOrder order, H5O_iterate_t op, void *op_data, hid_t lapl_id)
927   {
928     throwOnError(H5Ovisit_by_name(loc_id,toStringz(obj_name),idx_type,order,op,op_data,lapl_id));
929   }
930  
931  
932   void close(hid_t object_id)
933   {
934     throwOnError(H5Oclose(object_id));
935   }
936   }//static
937 }
938  
939 struct H5P
940 {
941   static
942   {
943     hid_t create_class(hid_t parent, string name, H5P_cls_create_func_t cls_create, void *create_data, H5P_cls_copy_func_t cls_copy, void *copy_data, H5P_cls_close_func_t cls_close, void *close_data)
944   {
945     return H5Pcreate_class(parent,toStringz(name),cls_create,create_data,cls_copy,copy_data,cls_close,close_data);
946   }
947  
948  
949   string get_class_name(hid_t pclass_id)
950   {
951     return ZtoString(H5Pget_class_name(pclass_id));
952   }
953  
954  
955   hid_t create(hid_t cls_id)
956   {
957     return H5Pcreate(cls_id);
958   }
959  
960  
961   void register2(hid_t cls_id, string name, size_t size, void *def_value, H5P_prp_create_func_t prp_create, H5P_prp_set_func_t prp_set, H5P_prp_get_func_t prp_get, H5P_prp_delete_func_t prp_del, H5P_prp_copy_func_t prp_copy, H5P_prp_compare_func_t prp_cmp, H5P_prp_close_func_t prp_close)
962   {
963     throwOnError(H5Pregister2(cls_id,toStringz(name),size,def_value,prp_create,prp_set,prp_get,prp_del,prp_copy,prp_cmp,prp_close));
964   }
965  
966  
967   void insert2(hid_t plist_id, string name, size_t size, void *value, H5P_prp_set_func_t prp_set, H5P_prp_get_func_t prp_get, H5P_prp_delete_func_t prp_delete, H5P_prp_copy_func_t prp_copy, H5P_prp_compare_func_t prp_cmp, H5P_prp_close_func_t prp_close)
968   {
969     throwOnError(H5Pinsert2(plist_id,toStringz(name),size,value,prp_set,prp_get,prp_delete,prp_copy,prp_cmp,prp_close));
970   }
971  
972  
973   void set(hid_t plist_id, string name, string value)
974   {
975     void *buf=cast(void*)toStringz(value);
976     throwOnError(H5Pset(plist_id,toStringz(name),buf));
977   }
978  
979  
980   htri_t exist(hid_t plist_id, string name)
981   {
982     return H5Pexist(plist_id,toStringz(name));
983   }
984  
985  
986   size_t get_size(hid_t id, string name)
987   {
988     size_t size;
989     throwOnError(H5Pget_size(id,toStringz(name),&size));
990     return size;
991   }
992  
993  
994   size_t get_nprops(hid_t id)
995   {
996     size_t nprop;
997     throwOnError(H5Pget_nprops(id,&nprop));
998     return nprop;
999   }
1000  
1001  
1002   hid_t get_class(hid_t plist_id)
1003   {
1004     return H5Pget_class(plist_id);
1005   }
1006  
1007  
1008   hid_t get_class_parent(hid_t pclass_id)
1009   {
1010     return H5Pget_class_parent(pclass_id);
1011   }
1012  
1013  
1014   void get(hid_t plist_id, string name, void * value)
1015   {
1016     throwOnError(H5Pget(plist_id,toStringz(name),value));
1017   }
1018  
1019  
1020   htri_t equal(hid_t id1, hid_t id2)
1021   {
1022     return H5Pequal(id1,id2);
1023   }
1024  
1025  
1026   htri_t isa_class(hid_t plist_id, hid_t pclass_id)
1027   {
1028     return H5Pisa_class(plist_id,pclass_id);
1029   }
1030  
1031  
1032   int iterate(hid_t id, int *idx, H5P_iterate_t iter_func, void *iter_data)
1033   {
1034     return H5Piterate(id,idx,iter_func,iter_data);
1035   }
1036  
1037  
1038   void copy_prop(hid_t dst_id, hid_t src_id, string name)
1039   {
1040     throwOnError(H5Pcopy_prop(dst_id,src_id,toStringz(name)));
1041   }
1042  
1043  
1044   void remove(hid_t plist_id, string name)
1045   {
1046     throwOnError(H5Premove(plist_id,toStringz(name)));
1047   }
1048  
1049  
1050   void unregister(hid_t pclass_id, string name)
1051   {
1052     throwOnError(H5Punregister(pclass_id,toStringz(name)));
1053   }
1054  
1055  
1056   void close_class(hid_t plist_id)
1057   {
1058     throwOnError(H5Pclose_class(plist_id));
1059   }
1060  
1061  
1062   void close(hid_t plist_id)
1063   {
1064     throwOnError(H5Pclose(plist_id));
1065   }
1066  
1067  
1068   hid_t copy(hid_t plist_id)
1069   {
1070     return H5Pcopy(plist_id);
1071   }
1072  
1073  
1074   void set_attr_phase_change(hid_t plist_id, uint max_compact, uint min_dense)
1075   {
1076     throwOnError(H5Pset_attr_phase_change(plist_id,max_compact,min_dense));
1077   }
1078  
1079  
1080   void get_attr_phase_change(hid_t plist_id, uint *max_compact, uint *min_dense)
1081   {
1082     throwOnError(H5Pget_attr_phase_change(plist_id,max_compact,min_dense));
1083   }
1084  
1085  
1086   void set_attr_creation_order(hid_t plist_id, uint crt_order_flags)
1087   {
1088     throwOnError(H5Pset_attr_creation_order(plist_id,crt_order_flags));
1089   }
1090  
1091  
1092   void get_attr_creation_order(hid_t plist_id, uint *crt_order_flags)
1093   {
1094     throwOnError(H5Pget_attr_creation_order(plist_id,crt_order_flags));
1095   }
1096  
1097  
1098   void set_obj_track_times(hid_t plist_id, hbool_t track_times)
1099   {
1100     throwOnError(H5Pset_obj_track_times(plist_id,track_times));
1101   }
1102  
1103  
1104   hbool_t get_obj_track_times(hid_t plist_id)
1105   {
1106     hbool_t track_times;
1107     throwOnError(H5Pget_obj_track_times(plist_id,&track_times));
1108     return track_times;
1109   }
1110  
1111  
1112   void modify_filter(hid_t plist_id, H5ZFilter filter, int flags, size_t cd_nelmts, const int[] cd_values)
1113   {
1114     throwOnError(H5Pmodify_filter(plist_id,filter,flags,cd_nelmts,cast(const int*)&cd_values));
1115   }
1116  
1117  
1118   void set_filter(hid_t plist_id, H5ZFilter filter, int flags, size_t cd_nelmts, const int[] c_values)
1119   {
1120     throwOnError(H5Pset_filter(plist_id,filter,flags,cd_nelmts,c_values.ptr));
1121   }
1122  
1123  
1124   int get_nfilters(hid_t plist_id)
1125   {
1126     return H5Pget_nfilters(plist_id);
1127   }
1128  
1129  
1130   H5ZFilter get_filter2(hid_t plist_id, uint filter, int *flags/*out*/, size_t *cd_nelmts/*out*/, uint[] cd_values/*out*/, size_t namelen, char[] name, uint *filter_config /*out*/)
1131   {
1132     return H5Pget_filter2(plist_id,filter,flags/*out*/,cd_nelmts/*out*/,cd_values.ptr/*out*/,namelen,name.ptr,filter_config);
1133   }
1134  
1135  
1136   void get_filter_by_id2(hid_t plist_id, H5ZFilter id, uint *flags/*out*/, size_t *cd_nelmts/*out*/, int[] cd_values/*out*/, size_t namelen, char[] name/*out*/, int *filter_config/*out*/)
1137   {
1138     throwOnError(H5Pget_filter_by_id2(plist_id,id,flags/*out*/,cd_nelmts/*out*/,cd_values.ptr/*out*/,namelen,name.ptr,filter_config));
1139   }
1140  
1141  
1142   htri_t all_filters_avail(hid_t plist_id)
1143   {
1144     return H5Pall_filters_avail(plist_id);
1145   }
1146  
1147  
1148   void remove_filter(hid_t plist_id, H5ZFilter filter)
1149   {
1150     throwOnError(H5Premove_filter(plist_id,filter));
1151   }
1152  
1153  
1154   void set_deflate(hid_t plist_id, int aggression)
1155   {
1156     throwOnError(H5Pset_deflate(plist_id,aggression));
1157   }
1158  
1159  
1160   void set_fletcher32(hid_t plist_id)
1161   {
1162     throwOnError(H5Pset_fletcher32(plist_id));
1163   }
1164  
1165  
1166   void get_version(hid_t plist_id, uint *boot/*out*/, uint *freelist/*out*/, uint *stab/*out*/, uint *shhdr/*out*/)
1167   {
1168     throwOnError(H5Pget_version(plist_id,boot/*out*/,freelist/*out*/,stab/*out*/,shhdr/*out*/));
1169   }
1170  
1171  
1172   void set_userblock(hid_t plist_id, hsize_t size)
1173   {
1174     throwOnError(H5Pset_userblock(plist_id,size));
1175   }
1176  
1177  
1178   void get_userblock(hid_t plist_id, hsize_t *size)
1179   {
1180     throwOnError(H5Pget_userblock(plist_id,size));
1181   }
1182  
1183  
1184   void set_sizes(hid_t plist_id, size_t sizeof_addr, size_t sizeof_size)
1185   {
1186     throwOnError(H5Pset_sizes(plist_id,sizeof_addr,sizeof_size));
1187   }
1188  
1189  
1190   void get_sizes(hid_t plist_id, size_t *sizeof_addr/*out*/, size_t *sizeof_size/*out*/)
1191   {
1192     throwOnError(H5Pget_sizes(plist_id,sizeof_addr/*out*/,sizeof_size/*out*/));
1193   }
1194  
1195  
1196   void set_sym_k(hid_t plist_id, uint ik, uint lk)
1197   {
1198     throwOnError(H5Pset_sym_k(plist_id,ik,lk));
1199   }
1200  
1201  
1202   void get_sym_k(hid_t plist_id, uint *ik/*out*/, uint *lk/*out*/)
1203   {
1204     throwOnError(H5Pget_sym_k(plist_id,ik/*out*/,lk/*out*/));
1205   }
1206  
1207  
1208   void set_istore_k(hid_t plist_id, uint ik)
1209   {
1210     throwOnError(H5Pset_istore_k(plist_id,ik));
1211   }
1212  
1213  
1214   void get_istore_k(hid_t plist_id, uint *ik/*out*/)
1215   {
1216     throwOnError(H5Pget_istore_k(plist_id,ik/*out*/));
1217   }
1218  
1219  
1220   void set_shared_mesg_nindexes(hid_t plist_id, uint nindexes)
1221   {
1222     throwOnError(H5Pset_shared_mesg_nindexes(plist_id,nindexes));
1223   }
1224  
1225  
1226   void get_shared_mesg_nindexes(hid_t plist_id, uint *nindexes)
1227   {
1228     throwOnError(H5Pget_shared_mesg_nindexes(plist_id,nindexes));
1229   }
1230  
1231  
1232   void set_shared_mesg_index(hid_t plist_id, uint index_num, uint mesg_type_flags, uint min_mesg_size)
1233   {
1234     throwOnError(H5Pset_shared_mesg_index(plist_id,index_num,mesg_type_flags,min_mesg_size));
1235   }
1236  
1237  
1238   void get_shared_mesg_index(hid_t plist_id, uint index_num, uint *mesg_type_flags, uint *min_mesg_size)
1239   {
1240     throwOnError(H5Pget_shared_mesg_index(plist_id,index_num,mesg_type_flags,min_mesg_size));
1241   }
1242  
1243  
1244   void set_shared_mesg_phase_change(hid_t plist_id, uint max_list, uint min_btree)
1245   {
1246     throwOnError(H5Pset_shared_mesg_phase_change(plist_id,max_list,min_btree));
1247   }
1248  
1249  
1250   void get_shared_mesg_phase_change(hid_t plist_id, uint *max_list, uint *min_btree)
1251   {
1252     throwOnError(H5Pget_shared_mesg_phase_change(plist_id,max_list,min_btree));
1253   }
1254  
1255  
1256   void set_alignment(hid_t fapl_id, hsize_t threshold, hsize_t alignment)
1257   {
1258     throwOnError(H5Pset_alignment(fapl_id,threshold,alignment));
1259   }
1260  
1261  
1262   void get_alignment(hid_t fapl_id, hsize_t *threshold/*out*/, hsize_t *alignment/*out*/)
1263   {
1264     throwOnError(H5Pget_alignment(fapl_id,threshold/*out*/,alignment/*out*/));
1265   }
1266  
1267  
1268   void set_driver(hid_t plist_id, hid_t driver_id, const void *driver_info)
1269   {
1270     throwOnError(H5Pset_driver(plist_id,driver_id,driver_info));
1271   }
1272  
1273  
1274   hid_t get_driver(hid_t plist_id)
1275   {
1276     return H5Pget_driver(plist_id);
1277   }
1278  
1279  
1280   void *get_driver_info(hid_t plist_id)
1281   {
1282     return H5Pget_driver_info(plist_id);
1283   }
1284  
1285  
1286   void set_family_offset(hid_t fapl_id, hsize_t offset)
1287   {
1288     throwOnError(H5Pset_family_offset(fapl_id,offset));
1289   }
1290  
1291  
1292   void get_family_offset(hid_t fapl_id, hsize_t *offset)
1293   {
1294     throwOnError(H5Pget_family_offset(fapl_id,offset));
1295   }
1296  
1297  
1298   void set_cache(hid_t plist_id, int mdc_nelmts, size_t rdcc_nslots, size_t rdcc_nbytes, double rdcc_w0)
1299   {
1300     throwOnError(H5Pset_cache(plist_id,mdc_nelmts,rdcc_nslots,rdcc_nbytes,rdcc_w0));
1301   }
1302  
1303  
1304   void get_cache(hid_t plist_id, int *mdc_nelmts, /* out */ size_t *rdcc_nslots/*out*/, size_t *rdcc_nbytes/*out*/, double *rdcc_w0)
1305   {
1306     throwOnError(H5Pget_cache(plist_id,mdc_nelmts,rdcc_nslots,rdcc_nbytes/*out*/,rdcc_w0));
1307   }
1308  
1309  
1310   void set_gc_references(hid_t fapl_id, uint gc_ref)
1311   {
1312     throwOnError(H5Pset_gc_references(fapl_id,gc_ref));
1313   }
1314  
1315  
1316   void get_gc_references(hid_t fapl_id, uint *gc_ref/*out*/)
1317   {
1318     throwOnError(H5Pget_gc_references(fapl_id,gc_ref/*out*/));
1319   }
1320  
1321  
1322   void set_fclose_degree(hid_t fapl_id, H5F_close_degree_t degree)
1323   {
1324     throwOnError(H5Pset_fclose_degree(fapl_id,degree));
1325   }
1326  
1327  
1328   void get_fclose_degree(hid_t fapl_id, H5F_close_degree_t *degree)
1329   {
1330     throwOnError(H5Pget_fclose_degree(fapl_id,degree));
1331   }
1332  
1333  
1334   void set_meta_block_size(hid_t fapl_id, hsize_t size)
1335   {
1336     throwOnError(H5Pset_meta_block_size(fapl_id,size));
1337   }
1338  
1339  
1340   void get_meta_block_size(hid_t fapl_id, hsize_t *size/*out*/)
1341   {
1342     throwOnError(H5Pget_meta_block_size(fapl_id,size/*out*/));
1343   }
1344  
1345  
1346   void set_sieve_buf_size(hid_t fapl_id, size_t size)
1347   {
1348     throwOnError(H5Pset_sieve_buf_size(fapl_id,size));
1349   }
1350  
1351  
1352   void get_sieve_buf_size(hid_t fapl_id, size_t *size/*out*/)
1353   {
1354     throwOnError(H5Pget_sieve_buf_size(fapl_id,size/*out*/));
1355   }
1356  
1357  
1358   void set_small_data_block_size(hid_t fapl_id, hsize_t size)
1359   {
1360     throwOnError(H5Pset_small_data_block_size(fapl_id,size));
1361   }
1362  
1363  
1364   void get_small_data_block_size(hid_t fapl_id, hsize_t *size/*out*/)
1365   {
1366     throwOnError(H5Pget_small_data_block_size(fapl_id,size/*out*/));
1367   }
1368  
1369  
1370   void set_libver_bounds(hid_t plist_id, H5F_libver_t low, H5F_libver_t high)
1371   {
1372     throwOnError(H5Pset_libver_bounds(plist_id,low,high));
1373   }
1374  
1375  
1376   void get_libver_bounds(hid_t plist_id, H5F_libver_t *low, H5F_libver_t *high)
1377   {
1378     throwOnError(H5Pget_libver_bounds(plist_id,low,high));
1379   }
1380  
1381  
1382   void set_elink_file_cache_size(hid_t plist_id, uint efc_size)
1383   {
1384     throwOnError(H5Pset_elink_file_cache_size(plist_id,efc_size));
1385   }
1386  
1387  
1388   void get_elink_file_cache_size(hid_t plist_id, uint *efc_size)
1389   {
1390     throwOnError(H5Pget_elink_file_cache_size(plist_id,efc_size));
1391   }
1392  
1393  
1394   void set_file_image(hid_t fapl_id, void *buf_ptr, size_t buf_len)
1395   {
1396     throwOnError(H5Pset_file_image(fapl_id,buf_ptr,buf_len));
1397   }
1398  
1399  
1400   void get_file_image(hid_t fapl_id, void **buf_ptr_ptr, size_t *buf_len_ptr)
1401   {
1402     throwOnError(H5Pget_file_image(fapl_id,buf_ptr_ptr,buf_len_ptr));
1403   }
1404  
1405  
1406   version(h5parallel)
1407   {
1408     void set_core_write_tracking(hid_t fapl_id, hbool_t is_enabled, size_t page_size)
1409     {
1410       throwOnError(H5Pset_core_write_tracking(fapl_id,is_enabled,page_size));
1411     }
1412    
1413    
1414     void get_core_write_tracking(hid_t fapl_id, hbool_t *is_enabled, size_t *page_size)
1415     {
1416       throwOnError(H5Pget_core_write_tracking(fapl_id,is_enabled,page_size));
1417     }
1418   }   
1419  
1420   void set_layout(hid_t plist_id, H5DLayout layout)
1421   {
1422     throwOnError(H5Pset_layout(plist_id,layout));
1423   }
1424  
1425  
1426   H5DLayout get_layout(hid_t plist_id)
1427   {
1428     return H5Pget_layout(plist_id);
1429   }
1430  
1431  
1432   void set_chunk(hid_t plist_id, in hsize_t[] dims)
1433   {
1434     int ndims=cast(int)dims.length;
1435     throwOnError(H5Pset_chunk(plist_id,ndims,cast(const hsize_t*)dims));
1436   }
1437  
1438  
1439   int get_chunk(hid_t plist_id, hsize_t[] dim/*out*/)
1440   {
1441     int max_ndims=to!int(dim.length);
1442     writefln("*MAX_ndims: %s",max_ndims);
1443     return H5Pget_chunk(plist_id,max_ndims,cast(hsize_t*)dim/*out*/);
1444   }
1445  
1446  
1447   void set_external(hid_t plist_id, string name, off_t offset, hsize_t size)
1448   {
1449     throwOnError(H5Pset_external(plist_id,toStringz(name),offset,size));
1450   }
1451  
1452  
1453   int get_external_count(hid_t plist_id)
1454   {
1455     return H5Pget_external_count(plist_id);
1456   }
1457  
1458  
1459   void get_external(hid_t plist_id, uint idx, size_t name_size, char *name/*out*/, off_t *offset/*out*/, hsize_t *size/*out*/)
1460   {
1461     throwOnError(H5Pget_external(plist_id,idx,name_size,name/*out*/,offset/*out*/,size/*out*/));
1462   }
1463  
1464  
1465   void set_szip(hid_t plist_id, uint options_mask, uint pixels_per_block)
1466   {
1467     throwOnError(H5Pset_szip(plist_id,options_mask,pixels_per_block));
1468   }
1469  
1470  
1471   void set_shuffle(hid_t plist_id)
1472   {
1473     throwOnError(H5Pset_shuffle(plist_id));
1474   }
1475  
1476  
1477   void set_nbit(hid_t plist_id)
1478   {
1479     throwOnError(H5Pset_nbit(plist_id));
1480   }
1481  
1482  
1483   void set_scaleoffset(hid_t plist_id, H5Z_SO_scale_type_t scale_type, int scale_factor)
1484   {
1485     throwOnError(H5Pset_scaleoffset(plist_id,scale_type,scale_factor));
1486   }
1487  
1488  
1489   void set_fill_value(hid_t plist_id, hid_t type_id, const void *value)
1490   {
1491     throwOnError(H5Pset_fill_value(plist_id,type_id,value));
1492   }
1493  
1494  
1495   void get_fill_value(hid_t plist_id, hid_t type_id, void *value/*out*/)
1496   {
1497     throwOnError(H5Pget_fill_value(plist_id,type_id,value/*out*/));
1498   }
1499  
1500  
1501   void fill_value_defined(hid_t plist, H5D_fill_value_t *status)
1502   {
1503     throwOnError(H5Pfill_value_defined(plist,status));
1504   }
1505  
1506  
1507   void set_alloc_time(hid_t plist_id, H5DAllocTime alloc_time)
1508   {
1509     throwOnError(H5Pset_alloc_time(plist_id,alloc_time));
1510   }
1511  
1512  
1513   void get_alloc_time(hid_t plist_id, H5DAllocTime *alloc_time/*out*/)
1514   {
1515     throwOnError(H5Pget_alloc_time(plist_id,alloc_time/*out*/));
1516   }
1517  
1518  
1519   void set_fill_time(hid_t plist_id, H5D_fill_time_t fill_time)
1520   {
1521     throwOnError(H5Pset_fill_time(plist_id,fill_time));
1522   }
1523  
1524  
1525   void get_fill_time(hid_t plist_id, H5D_fill_time_t *fill_time/*out*/)
1526   {
1527     throwOnError(H5Pget_fill_time(plist_id,fill_time/*out*/));
1528   }
1529  
1530  
1531   void set_chunk_cache(hid_t dapl_id, size_t rdcc_nslots, size_t rdcc_nbytes, double rdcc_w0)
1532   {
1533     throwOnError(H5Pset_chunk_cache(dapl_id,rdcc_nslots,rdcc_nbytes,rdcc_w0));
1534   }
1535  
1536  
1537   void get_chunk_cache(hid_t dapl_id, size_t *rdcc_nslots/*out*/, size_t *rdcc_nbytes/*out*/, double *rdcc_w0/*out*/)
1538   {
1539     throwOnError(H5Pget_chunk_cache(dapl_id,rdcc_nslots/*out*/,rdcc_nbytes/*out*/,rdcc_w0/*out*/));
1540   }
1541  
1542  
1543   void set_data_transform(hid_t plist_id, string expression)
1544   {
1545     throwOnError(H5Pset_data_transform(plist_id,toStringz(expression)));
1546   }
1547  
1548  
1549   auto get_data_transform(hid_t plist_id,ref ubyte[] buf)
1550   {
1551     buf~='\0';
1552     return (H5Pget_data_transform(plist_id,cast(char*)buf.ptr,buf.length.to!int));
1553   }
1554  
1555  
1556   void set_buffer(hid_t plist_id, size_t size, void *tconv, void *bkg)
1557   {
1558     throwOnError(H5Pset_buffer(plist_id,size,tconv,bkg));
1559   }
1560  
1561  
1562   size_t get_buffer(hid_t plist_id, void **tconv/*out*/, void **bkg/*out*/)
1563   {
1564     return H5Pget_buffer(plist_id,tconv/*out*/,bkg/*out*/);
1565   }
1566  
1567  
1568   void set_preserve(hid_t plist_id, hbool_t status)
1569   {
1570     throwOnError(H5Pset_preserve(plist_id,status));
1571   }
1572  
1573  
1574   int get_preserve(hid_t plist_id)
1575   {
1576     return H5Pget_preserve(plist_id);
1577   }
1578  
1579  
1580   void set_edc_check(hid_t plist_id, H5Z_EDC_t check)
1581   {
1582     throwOnError(H5Pset_edc_check(plist_id,check));
1583   }
1584  
1585  
1586   H5Z_EDC_t get_edc_check(hid_t plist_id)
1587   {
1588     return H5Pget_edc_check(plist_id);
1589   }
1590  
1591  
1592   void set_filter_callback(hid_t plist_id, H5Z_filter_func_t func, void* op_data)
1593   {
1594     throwOnError(H5Pset_filter_callback(plist_id,func,op_data));
1595   }
1596  
1597  
1598   void set_btree_ratios(hid_t plist_id, double left, double middle, double right)
1599   {
1600     throwOnError(H5Pset_btree_ratios(plist_id,left,middle,right));
1601   }
1602  
1603  
1604   void get_btree_ratios(hid_t plist_id, double *left/*out*/, double *middle/*out*/, double *right/*out*/)
1605   {
1606     throwOnError(H5Pget_btree_ratios(plist_id,left/*out*/,middle/*out*/,right/*out*/));
1607   }
1608  
1609  
1610   void set_hyper_vector_size(hid_t fapl_id, size_t size)
1611   {
1612     throwOnError(H5Pset_hyper_vector_size(fapl_id,size));
1613   }
1614  
1615  
1616   void get_hyper_vector_size(hid_t fapl_id, size_t *size/*out*/)
1617   {
1618     throwOnError(H5Pget_hyper_vector_size(fapl_id,size/*out*/));
1619   }
1620  
1621  
1622   void set_type_conv_cb(hid_t dxpl_id, H5T_conv_except_func_t op, void* operate_data)
1623   {
1624     throwOnError(H5Pset_type_conv_cb(dxpl_id,op,operate_data));
1625   }
1626  
1627  
1628   void get_type_conv_cb(hid_t dxpl_id, H5T_conv_except_func_t *op, void** operate_data)
1629   {
1630     throwOnError(H5Pget_type_conv_cb(dxpl_id,op,operate_data));
1631   }
1632  
1633  
1634   version(h5parallel)
1635   {
1636     void get_mpio_actual_chunk_opt_mode(hid_t plist_id, H5D_mpio_actual_chunk_opt_mode_t *actual_chunk_opt_mode)
1637     {
1638       throwOnError(H5Pget_mpio_actual_chunk_opt_mode(plist_id,actual_chunk_opt_mode));
1639     }
1640    
1641    
1642     void get_mpio_actual_io_mode(hid_t plist_id, H5D_mpio_actual_io_mode_t *actual_io_mode)
1643     {
1644       throwOnError(H5Pget_mpio_actual_io_mode(plist_id,actual_io_mode));
1645     }
1646    
1647    
1648     void get_mpio_no_collective_cause(hid_t plist_id, uint32_t *local_no_collective_cause, uint32_t *global_no_collective_cause)
1649     {
1650       throwOnError(H5Pget_mpio_no_collective_cause(plist_id,local_no_collective_cause,global_no_collective_cause));
1651     }
1652   }   
1653  
1654   void set_create_intermediate_group(hid_t plist_id, uint crt_intmd)
1655   {
1656     throwOnError(H5Pset_create_intermediate_group(plist_id,crt_intmd));
1657   }
1658  
1659  
1660   void get_create_intermediate_group(hid_t plist_id, uint *crt_intmd /*out*/)
1661   {
1662     throwOnError(H5Pget_create_intermediate_group(plist_id,crt_intmd));
1663   }
1664  
1665  
1666   void set_local_heap_size_hint(hid_t plist_id, size_t size_hint)
1667   {
1668     throwOnError(H5Pset_local_heap_size_hint(plist_id,size_hint));
1669   }
1670  
1671  
1672   void get_local_heap_size_hint(hid_t plist_id, size_t *size_hint /*out*/)
1673   {
1674     throwOnError(H5Pget_local_heap_size_hint(plist_id,size_hint));
1675   }
1676  
1677  
1678   void set_link_phase_change(hid_t plist_id, uint max_compact, uint min_dense)
1679   {
1680     throwOnError(H5Pset_link_phase_change(plist_id,max_compact,min_dense));
1681   }
1682  
1683  
1684   void get_link_phase_change(hid_t plist_id, uint *max_compact /*out*/, uint *min_dense /*out*/)
1685   {
1686     throwOnError(H5Pget_link_phase_change(plist_id,max_compact,min_dense));
1687   }
1688  
1689  
1690   void set_est_link_info(hid_t plist_id, uint est_num_entries, uint est_name_len)
1691   {
1692     throwOnError(H5Pset_est_link_info(plist_id,est_num_entries,est_name_len));
1693   }
1694  
1695  
1696   void get_est_link_info(hid_t plist_id, uint *est_num_entries /* out */, uint *est_name_len /* out */)
1697   {
1698     throwOnError(H5Pget_est_link_info(plist_id,est_num_entries,est_name_len));
1699   }
1700  
1701  
1702   void set_link_creation_order(hid_t plist_id, uint crt_order_flags)
1703   {
1704     throwOnError(H5Pset_link_creation_order(plist_id,crt_order_flags));
1705   }
1706  
1707  
1708   void get_link_creation_order(hid_t plist_id, uint *crt_order_flags /* out */)
1709   {
1710     throwOnError(H5Pget_link_creation_order(plist_id,crt_order_flags));
1711   }
1712  
1713  
1714   void set_char_encoding(hid_t plist_id, H5TCset encoding)
1715   {
1716     throwOnError(H5Pset_char_encoding(plist_id,encoding));
1717   }
1718  
1719  
1720   void get_char_encoding(hid_t plist_id, H5TCset *encoding /*out*/)
1721   {
1722     throwOnError(H5Pget_char_encoding(plist_id,encoding));
1723   }
1724  
1725  
1726   void set_nlinks(hid_t plist_id, size_t nlinks)
1727   {
1728     throwOnError(H5Pset_nlinks(plist_id,nlinks));
1729   }
1730  
1731  
1732   void get_nlinks(hid_t plist_id, size_t *nlinks)
1733   {
1734     throwOnError(H5Pget_nlinks(plist_id,nlinks));
1735   }
1736  
1737  
1738   void set_elink_prefix(hid_t plist_id, string prefix)
1739   {
1740     throwOnError(H5Pset_elink_prefix(plist_id,toStringz(prefix)));
1741   }
1742  
1743  
1744   string get_elink_prefix(hid_t plist_id)
1745   {
1746     char[2048] buf;
1747     if (H5Pget_elink_prefix(plist_id,cast(char*)buf,buf.length)<=0)
1748       return "";
1749     else
1750       return ZtoString(buf[]);
1751   }
1752  
1753  
1754   hid_t get_elink_fapl(hid_t lapl_id)
1755   {
1756     return H5Pget_elink_fapl(lapl_id);
1757   }
1758  
1759  
1760   void set_elink_fapl(hid_t lapl_id, hid_t fapl_id)
1761   {
1762     throwOnError(H5Pset_elink_fapl(lapl_id,fapl_id));
1763   }
1764  
1765  
1766   void set_elink_acc_flags(hid_t lapl_id, uint flags)
1767   {
1768     throwOnError(H5Pset_elink_acc_flags(lapl_id,flags));
1769   }
1770  
1771  
1772   void get_elink_acc_flags(hid_t lapl_id, uint *flags)
1773   {
1774     throwOnError(H5Pget_elink_acc_flags(lapl_id,flags));
1775   }
1776  
1777  
1778   void set_copy_object(hid_t plist_id, uint crt_intmd)
1779   {
1780     throwOnError(H5Pset_copy_object(plist_id,crt_intmd));
1781   }
1782  
1783  
1784   void get_copy_object(hid_t plist_id, uint *crt_intmd /*out*/)
1785   {
1786     throwOnError(H5Pget_copy_object(plist_id,crt_intmd));
1787   }
1788  
1789  
1790   void add_merge_committed_dtype_path(hid_t plist_id, string path)
1791   {
1792     throwOnError(H5Padd_merge_committed_dtype_path(plist_id,toStringz(path)));
1793   }
1794  
1795  
1796   void free_merge_committed_dtype_paths(hid_t plist_id)
1797   {
1798     throwOnError(H5Pfree_merge_committed_dtype_paths(plist_id));
1799   }
1800   }//static
1801 }
1802 
1803 struct H5R
1804 {
1805   static
1806   {
1807     void create(void *_ref, hid_t loc_id, string name, H5RType ref_type, hid_t space_id)
1808     {
1809       throwOnError(H5Rcreate(_ref, loc_id, toStringz(name),ref_type,space_id));
1810     }
1811    hid_t dereference(hid_t dataset, H5RType ref_type, const void *_ref)
1812    {
1813       return H5Rdereference(dataset, ref_type, _ref);
1814    }
1815    hid_t get_region(hid_t dataset, H5RType ref_type, const void *_ref)
1816    {
1817       return  H5Rget_region(dataset, ref_type, _ref);
1818    }
1819    string get_name(hid_t loc_id, H5RType ref_type, const void *_ref)
1820    {
1821       char[2048] buf;
1822       if (H5Rget_name(loc_id, ref_type,_ref,cast(char*)buf,buf.length-1)<=0)
1823         return "";
1824       else
1825         return ZtoString(buf[]);
1826     }
1827     auto get_obj_type2(hid_t id, H5RType ref_type, const void *_ref)
1828     {
1829       H5OType obj_type;
1830       throwOnError(H5Rget_obj_type2( id, ref_type,_ref,  &obj_type));
1831       return obj_type;
1832     }
1833   } // static
1834 }
1835 
1836 struct H5S
1837 {
1838   static {
1839   hid_t create(H5SClass type)
1840   {
1841     return H5Screate(type);
1842   }
1843  
1844   hid_t create_simple(in hsize_t[] dims)
1845   {
1846     auto maxdims=dims;
1847     return create_simple(dims, maxdims);
1848   }
1849  
1850   hid_t create_simple(in hsize_t[] dims, in hsize_t[] maxdims)
1851   {
1852     if (maxdims.length!=dims.length)
1853       throw new Exception("H5S create_simple: maxdims="~to!string(maxdims.length)~" must be of same rank as dims="~to!string(dims.length));
1854     return H5Screate_simple(cast(int)dims.length, cast(const hsize_t*) dims,cast(const hsize_t*) maxdims);
1855   }
1856  
1857   void set_extent_simple(hid_t space_id, in hsize_t[] dims)
1858   {
1859     set_extent_simple(space_id,dims,dims);
1860   }
1861   
1862   void set_extent_simple(hid_t space_id, in hsize_t[] dims,in hsize_t[] max)
1863   {
1864     const(hsize_t)[] maxarg=max;
1865     int rank=to!int(dims.length);
1866     if ((max.length==0) && (dims.length>0))
1867       maxarg=dims;
1868     else
1869     {
1870       if (maxarg.length!=dims.length)
1871         throw new Exception("H5S: max dims "~to!string(maxarg.length)~" must be of same ranks as dims="~to!string(dims.length));
1872     }
1873     throwOnError(H5Sset_extent_simple(space_id,to!int(dims.length),cast(const hsize_t*)dims,cast(const hsize_t*)maxarg));
1874   }
1875  
1876  
1877   hid_t copy(hid_t space_id)
1878   {
1879     return H5Scopy(space_id);
1880   }
1881  
1882  
1883   void close(hid_t space_id)
1884   {
1885     throwOnError(H5Sclose(space_id));
1886   }
1887  
1888  
1889   void encode(hid_t obj_id, void *buf, size_t *nalloc)
1890   {
1891     throwOnError(H5Sencode(obj_id,buf,nalloc));
1892   }
1893  
1894  
1895   hid_t decode(const void *buf)
1896   {
1897     return H5Sdecode(buf);
1898   }
1899  
1900  
1901   hssize_t get_simple_extent_npoints(hid_t space_id)
1902   {
1903     return H5Sget_simple_extent_npoints(space_id);
1904   }
1905  
1906  
1907   int get_simple_extent_ndims(hid_t space_id)
1908   {
1909     return H5Sget_simple_extent_ndims(space_id);
1910   }
1911 
1912   int get_simple_extent_dims(hid_t space_id, hsize_t[] dims)
1913   {
1914     hsize_t[] maxdims;
1915     maxdims.length=dims.length;
1916     return H5Sget_simple_extent_dims(space_id,cast(hsize_t*)dims,cast(hsize_t*)maxdims);
1917   }
1918  
1919  
1920   int get_simple_extent_dims(hid_t space_id, hsize_t[] dims, hsize_t[] maxdims)
1921   {
1922     return H5Sget_simple_extent_dims(space_id,cast(hsize_t*)dims,cast(hsize_t*)maxdims);
1923   }
1924  
1925  
1926   htri_t is_simple(hid_t space_id)
1927   {
1928     return H5Sis_simple(space_id);
1929   }
1930  
1931  
1932   hssize_t get_select_npoints(hid_t spaceid)
1933   {
1934     return H5Sget_select_npoints(spaceid);
1935   }
1936  
1937  
1938   void select_hyperslab(hid_t filespace, H5SSeloper op, in hsize_t[] start,  in hsize_t[] count)
1939   {
1940      select_hyperslab(filespace, op, start, cast(hsize_t[])[], count, cast(hsize_t[])[]);
1941   }
1942 
1943   void select_hyperslab(hid_t space_id, H5SSeloper op, in hsize_t[] start, in hsize_t[] _stride, in hsize_t[] count, in hsize_t[] _block)
1944   {
1945     throwOnError(H5Sselect_hyperslab(space_id,op,cast(const hsize_t*)start,cast(const hsize_t*) _stride,cast(const hsize_t*)count,cast(const hsize_t*)_block));
1946   }
1947  
1948  
1949   version(h5parallel)
1950   {
1951     hid_t combine_hyperslab(hid_t space_id, H5SSeloper op, const hsize_t *start, const hsize_t *_stride, const hsize_t *count, const hsize_t *_block)
1952     {
1953       return H5Scombine_hyperslab(space_id,op,start,_stride,count,_block);
1954     }
1955    
1956    
1957     void select_select(hid_t space1_id, H5SSeloper op, hid_t space2_id)
1958     {
1959       throwOnError(H5Sselect_select(space1_id,op,space2_id));
1960     }
1961    
1962    
1963     hid_t combine_select(hid_t space1_id, H5SSeloper op, hid_t space2_id)
1964     {
1965       return H5Scombine_select(space1_id,op,space2_id);
1966     }
1967   } 
1968  
1969   void select_elements(hid_t space_id, H5SSeloper op, size_t num_elem, const hsize_t *coord)
1970   {
1971     throwOnError(H5Sselect_elements(space_id,op,num_elem,coord));
1972   }
1973  
1974  
1975   H5SClass get_simple_extent_type(hid_t space_id)
1976   {
1977     return H5Sget_simple_extent_type(space_id);
1978   }
1979  
1980  
1981   void set_extent_none(hid_t space_id)
1982   {
1983     throwOnError(H5Sset_extent_none(space_id));
1984   }
1985  
1986  
1987   void extent_copy(hid_t dst_id,hid_t src_id)
1988   {
1989     throwOnError(H5Sextent_copy(dst_id,src_id));
1990   }
1991  
1992  
1993   htri_t extent_equal(hid_t sid1, hid_t sid2)
1994   {
1995     return H5Sextent_equal(sid1,sid2);
1996   }
1997  
1998  
1999   void select_all(hid_t spaceid)
2000   {
2001     throwOnError(H5Sselect_all(spaceid));
2002   }
2003  
2004  
2005   void select_none(hid_t spaceid)
2006   {
2007     throwOnError(H5Sselect_none(spaceid));
2008   }
2009  
2010  
2011   void offset_simple(hid_t space_id, const hssize_t *offset)
2012   {
2013     throwOnError(H5Soffset_simple(space_id,offset));
2014   }
2015  
2016  
2017   htri_t select_valid(hid_t spaceid)
2018   {
2019     return H5Sselect_valid(spaceid);
2020   }
2021  
2022  
2023   hssize_t get_select_hyper_nblocks(hid_t spaceid)
2024   {
2025     return H5Sget_select_hyper_nblocks(spaceid);
2026   }
2027  
2028  
2029   hssize_t get_select_elem_npoints(hid_t spaceid)
2030   {
2031     return H5Sget_select_elem_npoints(spaceid);
2032   }
2033  
2034  
2035   void get_select_hyper_blocklist(hid_t spaceid, hsize_t startblock, hsize_t numblocks, hsize_t *buf)
2036   {
2037     throwOnError(H5Sget_select_hyper_blocklist(spaceid,startblock,numblocks,buf));
2038   }
2039  
2040  
2041   void get_select_elem_pointlist(hid_t spaceid, hsize_t startpoint, hsize_t numpoints, hsize_t *buf)
2042   {
2043     throwOnError(H5Sget_select_elem_pointlist(spaceid,startpoint,numpoints,buf));
2044   }
2045  
2046  
2047   void get_select_bounds(hid_t spaceid, hsize_t *start, hsize_t *end)
2048   {
2049     throwOnError(H5Sget_select_bounds(spaceid,start,end));
2050   }
2051  
2052  
2053   H5S_sel_type get_select_type(hid_t spaceid)
2054   {
2055     return H5Sget_select_type(spaceid);
2056   }
2057   }// static
2058 }
2059  
2060 struct H5T
2061 {
2062   static hid_t create(H5TClass type, size_t size)
2063   {
2064     return H5Tcreate(type,size);
2065   }
2066  
2067  
2068   static hid_t copy(hid_t type_id)
2069   {
2070     return H5Tcopy(type_id);
2071   }
2072  
2073  
2074   static void close(hid_t type_id)
2075   {
2076     throwOnError(H5Tclose(type_id));
2077   }
2078  
2079  
2080   static htri_t equal(hid_t type1_id, hid_t type2_id)
2081   {
2082     return H5Tequal(type1_id,type2_id);
2083   }
2084  
2085  
2086   static void lock(hid_t type_id)
2087   {
2088     throwOnError(H5Tlock(type_id));
2089   }
2090  
2091  
2092   static void commit2(hid_t loc_id, string name, hid_t type_id, hid_t lcpl_id, hid_t tcpl_id, hid_t tapl_id)
2093   {
2094     throwOnError(H5Tcommit2(loc_id,toStringz(name),type_id,lcpl_id,tcpl_id,tapl_id));
2095   }
2096  
2097  
2098   static hid_t open2(hid_t loc_id, string name, hid_t tapl_id)
2099   {
2100     return H5Topen2(loc_id,toStringz(name),tapl_id);
2101   }
2102  
2103  
2104   static void commit_anon(hid_t loc_id, hid_t type_id, hid_t tcpl_id, hid_t tapl_id)
2105   {
2106     throwOnError(H5Tcommit_anon(loc_id,type_id,tcpl_id,tapl_id));
2107   }
2108  
2109  
2110   static hid_t get_create_plist(hid_t type_id)
2111   {
2112     return H5Tget_create_plist(type_id);
2113   }
2114  
2115  
2116   static htri_t committed(hid_t type_id)
2117   {
2118     return H5Tcommitted(type_id);
2119   }
2120  
2121  
2122   static void encode(hid_t obj_id, void *buf, size_t *nalloc)
2123   {
2124     throwOnError(H5Tencode(obj_id,buf,nalloc));
2125   }
2126  
2127  
2128   static hid_t decode(const void *buf)
2129   {
2130     return H5Tdecode(buf);
2131   }
2132  
2133  
2134   static void insert(hid_t parent_id, string name, size_t offset, hid_t member_id)
2135   {
2136     throwOnError(H5Tinsert(parent_id,toStringz(name),offset,member_id));
2137   }
2138  
2139  
2140   static void pack(hid_t type_id)
2141   {
2142     throwOnError(H5Tpack(type_id));
2143   }
2144  
2145  
2146   static hid_t enum_create(hid_t base_id)
2147   {
2148     return H5Tenum_create(base_id);
2149   }
2150  
2151  
2152   static void enum_insert(hid_t type, string name, const void *value)
2153   {
2154     throwOnError(H5Tenum_insert(type,toStringz(name),value));
2155   }
2156  
2157  
2158   static string enum_nameof(hid_t type, const void *value)
2159   {
2160     char[2048] buf;
2161     throwOnError(H5Tenum_nameof(type,value,cast(char*)buf,buf.length));
2162     return ZtoString(buf[]);
2163   }
2164  
2165  
2166   static void enum_valueof(hid_t type, string name, void *value/*out*/)
2167   {
2168     throwOnError(H5Tenum_valueof(type,toStringz(name),value/*out*/));
2169   }
2170  
2171  
2172   static hid_t vlen_create(hid_t base_id)
2173   {
2174     return H5Tvlen_create(base_id);
2175   }
2176  
2177  
2178   static hid_t array_create2(hid_t base_id, uint ndims, const hsize_t[] dim)
2179   {
2180     return H5Tarray_create2(base_id,ndims,dim);
2181   }
2182  
2183  
2184   static int get_array_ndims(hid_t type_id)
2185   {
2186     return H5Tget_array_ndims(type_id);
2187   }
2188  
2189  
2190   static int get_array_dims2(hid_t type_id, hsize_t[] dims)
2191   {
2192     return H5Tget_array_dims2(type_id,cast(hsize_t*)&dims);
2193   }
2194  
2195  
2196   static void set_tag(hid_t type, string tag)
2197   {
2198     throwOnError(H5Tset_tag(type,toStringz(tag)));
2199   }
2200  
2201  
2202   static string get_tag(hid_t type_id)
2203   {
2204     return ZtoString(H5Tget_tag(type_id));
2205   }
2206  
2207  
2208   static hid_t get_super(hid_t type_id)
2209   {
2210     return H5Tget_super(type_id);
2211   }
2212  
2213  
2214   static H5TClass get_class(hid_t type_id)
2215   {
2216     return H5Tget_class(type_id);
2217   }
2218  
2219  
2220   static htri_t detect_class(hid_t type_id, H5TClass cls)
2221   {
2222     return H5Tdetect_class(type_id,cls);
2223   }
2224  
2225  
2226   static size_t get_size(hid_t type_id)
2227   {
2228    return H5Tget_size(type_id);
2229   }
2230  
2231  
2232   static H5TByteOrder get_order(hid_t type_id)
2233   {
2234    return H5Tget_order(type_id);
2235   }
2236  
2237  
2238   static size_t get_precision(hid_t type_id)
2239   {
2240    return H5Tget_precision(type_id);
2241   }
2242  
2243  
2244   static int get_offset(hid_t type_id)
2245   {
2246     return H5Tget_offset(type_id);
2247   }
2248  
2249  
2250   static void get_pad(hid_t type_id, H5T_pad_t *lsb/*out*/, H5T_pad_t *msb/*out*/)
2251   {
2252     throwOnError(H5Tget_pad(type_id,lsb/*out*/,msb/*out*/));
2253   }
2254  
2255  
2256   static H5T_sign_t get_sign(hid_t type_id)
2257   {
2258     return H5Tget_sign(type_id);
2259   }
2260  
2261  
2262   static void get_fields(hid_t type_id, size_t *spos/*out*/, size_t *epos/*out*/, size_t *esize/*out*/, size_t *mpos/*out*/, size_t *msize/*out*/)
2263   {
2264     throwOnError(H5Tget_fields(type_id,spos/*out*/,epos/*out*/,esize/*out*/,mpos/*out*/,msize/*out*/));
2265   }
2266  
2267  
2268   static size_t get_ebias(hid_t type_id)
2269   {
2270     return H5Tget_ebias(type_id);
2271   }
2272  
2273  
2274   static H5T_norm_t get_norm(hid_t type_id)
2275   {
2276     return H5Tget_norm(type_id);
2277   }
2278  
2279  
2280   static H5T_pad_t get_inpad(hid_t type_id)
2281   {
2282     return H5Tget_inpad(type_id);
2283   }
2284  
2285  
2286   static H5TString get_strpad(hid_t type_id)
2287   {
2288     return H5Tget_strpad(type_id);
2289   }
2290  
2291  
2292   static int get_nmembers(hid_t type_id)
2293   {
2294     return H5Tget_nmembers(type_id);
2295   }
2296  
2297  
2298   static string get_member_name(hid_t type_id, uint membno)
2299   {
2300     return ZtoString(H5Tget_member_name(type_id,membno));
2301   }
2302  
2303  
2304   static int get_member_index(hid_t type_id, string name)
2305   {
2306     return H5Tget_member_index(type_id,toStringz(name));
2307   }
2308  
2309  
2310   static size_t get_member_offset(hid_t type_id, uint membno)
2311   {
2312     return H5Tget_member_offset(type_id,membno);
2313   }
2314  
2315  
2316   static H5TClass get_member_class(hid_t type_id, uint membno)
2317   {
2318     return H5Tget_member_class(type_id,membno);
2319   }
2320  
2321  
2322   static hid_t get_member_type(hid_t type_id, uint membno)
2323   {
2324     return H5Tget_member_type(type_id,membno);
2325   }
2326  
2327  
2328   static void get_member_value(hid_t type_id, uint membno, void *value/*out*/)
2329   {
2330     throwOnError(H5Tget_member_value(type_id,membno,value/*out*/));
2331   }
2332  
2333  
2334   static H5TCset get_cset(hid_t type_id)
2335   {
2336     return H5Tget_cset(type_id);
2337   }
2338  
2339  
2340   static htri_t is_variable_str(hid_t type_id)
2341   {
2342   return H5Tis_variable_str(type_id);
2343   }
2344  
2345  
2346   static hid_t get_native_type(hid_t type_id, H5TDirection direction)
2347   {
2348   return H5Tget_native_type(type_id,direction);
2349   }
2350  
2351  
2352   static void set_size(hid_t type_id, size_t size)
2353   {
2354     throwOnError(H5Tset_size(type_id,size));
2355   }
2356  
2357  
2358   static void set_order(hid_t type_id, H5TByteOrder order)
2359   {
2360     throwOnError(H5Tset_order(type_id,order));
2361   }
2362  
2363  
2364   static void set_precision(hid_t type_id, size_t prec)
2365   {
2366     throwOnError(H5Tset_precision(type_id,prec));
2367   }
2368  
2369  
2370   static void set_offset(hid_t type_id, size_t offset)
2371   {
2372     throwOnError(H5Tset_offset(type_id,offset));
2373   }
2374  
2375  
2376   static void set_pad(hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
2377   {
2378     throwOnError(H5Tset_pad(type_id,lsb,msb));
2379   }
2380  
2381  
2382   static void set_sign(hid_t type_id, H5T_sign_t sign)
2383   {
2384     throwOnError(H5Tset_sign(type_id,sign));
2385   }
2386  
2387  
2388   static void set_fields(hid_t type_id, size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize)
2389   {
2390     throwOnError(H5Tset_fields(type_id,spos,epos,esize,mpos,msize));
2391   }
2392  
2393  
2394   static void set_ebias(hid_t type_id, size_t ebias)
2395   {
2396     throwOnError(H5Tset_ebias(type_id,ebias));
2397   }
2398  
2399  
2400   static void set_norm(hid_t type_id, H5T_norm_t norm)
2401   {
2402     throwOnError(H5Tset_norm(type_id,norm));
2403   }
2404  
2405  
2406   static void set_inpad(hid_t type_id, H5T_pad_t pad)
2407   {
2408     throwOnError(H5Tset_inpad(type_id,pad));
2409   }
2410  
2411  
2412   static void set_cset(hid_t type_id, H5TCset cset)
2413   {
2414     throwOnError(H5Tset_cset(type_id,cset));
2415   }
2416  
2417  
2418   static void set_strpad(hid_t type_id, H5TString strpad)
2419   {
2420     throwOnError(H5Tset_strpad(type_id,strpad));
2421   }
2422  
2423  
2424   static void register(H5T_pers_t pers, string name, hid_t src_id, hid_t dst_id, H5T_conv_t func)
2425   {
2426     throwOnError(H5Tregister(pers,toStringz(name),src_id,dst_id,func));
2427   }
2428  
2429  
2430   static void unregister(H5T_pers_t pers, string name, hid_t src_id, hid_t dst_id, H5T_conv_t func)
2431   {
2432     throwOnError(H5Tunregister(pers,toStringz(name),src_id,dst_id,func));
2433   }
2434  
2435  
2436   static H5T_conv_t find(hid_t src_id, hid_t dst_id, H5T_cdata_t **pcdata)
2437   {
2438     return H5Tfind(src_id,dst_id,pcdata);
2439   }
2440  
2441  
2442   static htri_t compiler_conv(hid_t src_id, hid_t dst_id)
2443   {
2444     return H5Tcompiler_conv(src_id,dst_id);
2445   }
2446  
2447  
2448   static void convert(hid_t src_id, hid_t dst_id, size_t nelmts, void *buf, void *background, hid_t plist_id)
2449   {
2450     throwOnError(H5Tconvert(src_id,dst_id,nelmts,buf,background,plist_id));
2451   }
2452 }
2453 
2454 struct H5Z
2455 {
2456     static void register(const void *cls)
2457     {
2458       throwOnError(H5Zregister(cls));
2459     }
2460 
2461     static void unregister(H5ZFilter id)
2462     {
2463       throwOnError(id);
2464     }
2465 
2466     static htri_t filter_avail(H5ZFilter id)
2467     {
2468       return H5Zfilter_avail(id);
2469     }
2470     static void get_filter_info(H5ZFilter filter, uint *filter_config_flags)
2471     {
2472       throwOnError(H5Zget_filter_info(filter, filter_config_flags));
2473     }
2474 }
2475 
2476 
2477 string[] findAttributes(hid_t obj_id)
2478 {
2479     hsize_t idx=0;
2480     string[] ret;
2481     H5A.iterate2(obj_id, H5Index.Name, H5IterOrder.Inc,  &idx, &myAttributeIterator, &ret);
2482     return ret;
2483 }
2484 
2485 extern(C) herr_t  myAttributeIterator( hid_t location_id/*in*/, const char *attr_name/*in*/, const H5A_info_t *ainfo/*in*/, void *op_data/*in,out*/)
2486 {
2487     auto attrib=cast(string[]*)op_data;
2488     (*attrib)~=ZtoString(attr_name);    
2489     return 0;
2490 } 
2491 
2492 string[] findLinks(hid_t group_id)
2493 {
2494     hsize_t idx=0;
2495     string[] ret;
2496     H5L.iterate(group_id, H5Index.Name, H5IterOrder.Inc,  &idx, &myLinkIterator, &ret);
2497     return ret;
2498 }
2499 
2500 extern(C) herr_t  myLinkIterator( hid_t g_id/*in*/, const char *name/*in*/, const H5LInfo* info/*in*/, void *op_data/*in,out*/)
2501 {
2502     auto linkstore=cast(string[]*)op_data;
2503     (*linkstore)~=ZtoString(name);    
2504     return 0;
2505 } 
2506 
2507 
2508 string[] dataSpaceContents(ubyte[] buf, hid_t type_id,hid_t space_id)
2509 {
2510     hsize_t idx=0;
2511     dataSpaceDescriptor[] ret;
2512     string[] rets;
2513     H5D.iterate(cast(void*)buf,type_id,space_id,&dataSpaceIterator,&ret);
2514     foreach(item;ret)
2515     {
2516         rets~=to!string(item.elemtype) ~ " " ~ to!string(item.ndim) ~ " " ~ to!string(item.point);
2517     }
2518     return rets;
2519 }
2520 
2521 struct dataSpaceDescriptor
2522 {
2523     hid_t elemtype;
2524     uint ndim;
2525     hsize_t point;
2526 }
2527 
2528 extern(C) herr_t  dataSpaceIterator(void* elem, hid_t type_id, int ndim, const hsize_t *point, void *op_data) 
2529 {
2530     auto store=cast(dataSpaceDescriptor[]*)op_data;
2531     dataSpaceDescriptor ret_elem;
2532     ret_elem.elemtype=type_id;
2533     ret_elem.ndim=ndim;
2534     ret_elem.point=*point;
2535     (*store)~=ret_elem;
2536     return 0;
2537 } 
2538 
2539 string[] propertyList(hid_t id) 
2540 {
2541     int idx=0;
2542     string[] ret;
2543     H5P.iterate(id, &idx, &myPropertyIterator, &ret);
2544     return ret;
2545 }
2546 
2547 extern(C) herr_t myPropertyIterator( hid_t id, const char *name, void *op_data )
2548 {
2549     auto namestore=cast(string[]*)op_data;
2550     (*namestore)~=ZtoString(name);    
2551     return 0;
2552 } 
2553 
2554 string[] objectList(hid_t id)
2555 {
2556     hsize_t idx=0;
2557     string[] ret;
2558     H5O.visit( id, H5Index.Name, H5IterOrder.Inc,&myObjectIterator,&ret );
2559     return ret;
2560 }
2561 
2562 extern(C) herr_t  myObjectIterator( hid_t g_id/*in*/, const char *name/*in*/, const H5OInfo* info/*in*/, void *op_data/*in,out*/)
2563 {
2564     auto linkstore=cast(string[]*)op_data;
2565     (*linkstore)~=ZtoString(name);    
2566     return 0;
2567 }